/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package business;

import java.io.FileDescriptor;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.net.ConnectException;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.rmi.NotBoundException;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import java.util.logging.Level;
import java.util.logging.Logger;

import stub.ConnectionException;
import stub.Data;
import stub.FileFoundException;
import stub.IData;
import stub.Protocolo;
import stub.StubInterface;

/**
 *
 * @author nacho
 */
public class Cliente {

    StubInterface objetoRemoto;

    public Cliente(URL url) throws RemoteException, NotBoundException {
    	Registry registry = LocateRegistry.getRegistry(url.getHost());
        objetoRemoto = (StubInterface) registry.lookup(Protocolo.API_FS);
    }

    protected void rcopy(String origen, String destino) {
        try {
            URI origenUri = new URI(origen);
            URI destinoUri = new URI(destino);
            

            if (origenUri.getHost() != null && destinoUri.getHost() != null) {
                //REMOTE_TO_REMOTE --> NONE
            }

            if (origenUri.getHost() == null && destinoUri.getHost() != null) {
                //LOCAL_TO_REMOTE --> PUT
//                Stub stub = new Stub();
//                copiar(new FileReader(origenUri.getPath()), new FileWriter(stub.rfsOpen(destinoUri.getPath())));
                //stub = new Stub(destinoUri.toURL());
                copiar(new FileInputStream(origenUri.getPath()), destinoUri.getPath().substring(1));
            }

            if (origenUri.getHost() != null && destinoUri.getHost() == null) {
                //REMOTE_TO_LOCAL --> GET
//                Stub stub = new Stub();
//                copiar(new FileWriter(destinoUri.getPath()), new FileReader(stub.rfsOpen(origenUri.getPath())));
             //   stub = new Stub(origenUri.toURL());
                copiar(origenUri.getPath().substring(1), new FileOutputStream(destinoUri.getPath()));
            }

            if (origenUri.getHost() == null && destinoUri.getHost() == null) {
                //LOCAL_TO_LOCAL --> COPY LOCAL
            }

        } catch (ConnectException ex) {
            System.err.println("El servidor no está disponible");
        } catch (ConnectionException ex) {
            System.err.println(ex.getMessage());
        } catch (FileFoundException ex) {
        	System.err.println("El archivo ya existe. ¿Desea sobreescribirlo?");
        } catch (IllegalAccessException ex) {
            Logger.getLogger(Cliente.class.getName()).log(Level.SEVERE, null, ex);
        } catch (FileNotFoundException ex) {
        	System.err.println("El archivo no existe. No se pudo leer");
        } catch (URISyntaxException ex) {
        	System.err.println("Error de sintaxis en la url especificada");
        } catch (IOException ex) {
        	System.err.println("El archivo no existe. No se pudo leer");
        }

    }

    protected void rcat(String nombreArchivo) throws IOException {
        //copiar(new FileWriter(FileDescriptor.out), new FileReader(nombreArchivo));
    	try {
    		
    		URI uri = new URI(nombreArchivo);
    		String filename;
    		
    		filename = uri.getPath().substring(1);

                copiar(filename, new FileOutputStream(FileDescriptor.out));
			
		} 
    	catch (URISyntaxException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
    	catch (ConnectionException ex) {
			System.out.println(ex.getMessage());
		} catch (FileFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
        
    
}

    private void copiar(FileReader origen, FileWriter destino) throws IOException {
        //PUT nombreArchivo en RFD destino
    	int car;
    	final int EOF = -1;
        
    	while ((car = origen.read()) != EOF){
    		destino.write(car);
    	}
    }
    
    /**
     * Sube un archivo al servidor
     * 
     * @param local
     * @param servidor
     * @throws FileNotFoundException
     * @throws IOException
     * @throws ConnectionException
     * @throws FileFoundException
     * @throws IllegalAccessException
     */
    private void copiar(FileInputStream local,String servidor) throws FileNotFoundException, IOException, ConnectionException, FileFoundException, IllegalAccessException{
    	//PUT
    	// preparacion
    	int fd;
    	//FileInputStream stream = new ObjectInputStream(local);
    	byte[] buffer = new byte[Protocolo.TAMANIO_BLOQUE];
    	int leidos;
    	
    	// crea el archivo en el servidor
    	fd = objetoRemoto.rfsOpen(servidor, Protocolo.WRITE);
    	
    	// copia en el servidor el archivo local
    	while((leidos = local.read(buffer)) > 0){
    		
        	objetoRemoto.rfsWrite(fd,servidor, buffer,leidos);
    	}
    	
    	// cierra los archivos
    	objetoRemoto.rfsClose(fd,servidor);
    	//stream.close();
    }
    
    /**
     * Descarga un archivo del servidor
     * 
     * @param servidor
     * @param local
     * @throws FileNotFoundException
     * @throws IOException
     * @throws ConnectionException
     * @throws FileFoundException
     * @throws IllegalAccessException
     */
    private void copiar(String servidor,FileOutputStream local) throws FileNotFoundException, IOException, ConnectionException, FileFoundException, IllegalAccessException{
    	// GET
    	// preparacion
    	int fd;
    	//FileOutputStream stream = new FileOutputStream(local);
    	byte[] buffer = new byte[Protocolo.TAMANIO_BLOQUE];
    	IData leidos;
    	
    	// abre el archivo en el servidor
    	fd = objetoRemoto.rfsOpen(servidor, Protocolo.READ);
    	System.out.println("Hice el open");
           
    	// copia localmente el contenido del archivo abierto
    	do {
            leidos = objetoRemoto.rfsRead(fd, servidor);
            if (leidos.getCargaUtil() > 0)
                local.write(leidos.getData(),0,(int)leidos.getCargaUtil());
    	} while((leidos.getCargaUtil() == Protocolo.TAMANIO_BLOQUE));

        System.out.println("hago el close");
    	// cierra los archivos
    	objetoRemoto.rfsClose(fd,servidor);
    	//stream.close();
    }

}
